JavaScript Asinxron Generatorlari: Oqimli Ma'lumotlarni Qayta Ishlash va Orqaga Bosim Tushuntirildi

Asinxron dasturlash zamonaviy JavaScript dasturlashining asosiy tamoyillaridan biri bo'lib, ilovalarga asosiy oqimni bloklamasdan I/O (kiritish/chiqarish) amallarini bajarish imkonini beradi. ECMAScript 2018 da taqdim etilgan asinxron generatorlar asinxron ma'lumotlar oqimlari bilan ishlashning kuchli va elegant usulini taklif qiladi. Ular asinxron funksiyalar va generatorlarning afzalliklarini birlashtirib, ma'lumotlarni bloklanmaydigan, takrorlanadigan tarzda qayta ishlash uchun mustahkam mexanizmni ta'minlaydi. Ushbu maqola JavaScript asinxron generatorlarini har tomonlama o'rganib chiqadi, bunda samarali va kengaytiriladigan ilovalar yaratish uchun zarur bo'lgan oqimli ma'lumotlarni qayta ishlash va orqaga bosimni boshqarish imkoniyatlariga e'tibor qaratiladi.

Asinxron Generatorlar Nima?

Asinxron generatorlarga sho'ng'ishdan oldin, keling, sinxron generatorlar va asinxron funksiyalarni qisqacha eslab o'tamiz. Sinxron generator — bu toʻxtatib turilishi va qayta ishga tushirilishi mumkin boʻlgan, qiymatlarni birma-bir qaytaradigan funksiya. Asinxron funksiya (async kalit so'zi bilan e'lon qilingan) har doim promise qaytaradi va promise hal bo'lguncha bajarilishni to'xtatib turish uchun await kalit so'zidan foydalanishi mumkin.

Asinxron generator — bu ikki tushunchani birlashtirgan funksiya. U async function* sintaksisi bilan e'lon qilinadi va asinxron iteratorni qaytaradi. Ushbu asinxron iterator sizga qiymatlar ustida asinxron tarzda iteratsiya qilish imkonini beradi, bunda keyingi qiymatga hal bo'ladigan promise'larni boshqarish uchun tsikl ichida await dan foydalaniladi.

Bu yerda oddiy misol keltirilgan:

            
async function* generateNumbers(max) {
  for (let i = 0; i < max; i++) {
    await new Promise(resolve => setTimeout(resolve, 500)); // Asinxron operatsiyani simulyatsiya qilish
    yield i;
  }
}

(async () => {
  for await (const number of generateNumbers(5)) {
    console.log(number);
  }
})();

            

              
                Copy
              
            
          

Ushbu misolda generateNumbers asinxron generator funksiyasidir. U har bir 'yield' orasida 500 ms kechikish bilan 0 dan 4 gacha raqamlarni qaytaradi. for await...of tsikli generator tomonidan qaytarilgan qiymatlar ustida asinxron tarzda iteratsiya qiladi. Har bir qaytarilgan qiymatni o'rab turgan promise'ni boshqarish uchun await ishlatilishiga e'tibor bering, bu tsiklning har bir qiymat tayyor bo'lguncha kutishini ta'minlaydi.

Asinxron Iteratorlarni Tushunish

Asinxron generatorlar asinxron iteratorlarni qaytaradi. Asinxron iterator — bu next() metodini ta'minlaydigan obyekt. next() metodi ikkita xususiyatga ega obyekt bilan hal bo'ladigan promise qaytaradi:

• value: Ketma-ketlikdagi keyingi qiymat.
• done: Iterator yakunlanganligini ko'rsatuvchi mantiqiy (boolean) qiymat.

for await...of tsikli avtomatik ravishda next() metodini chaqirishni va value hamda done xususiyatlarini ajratib olishni boshqaradi. Siz asinxron iterator bilan to'g'ridan-to'g'ri ham ishlashingiz mumkin, garchi bu kamroq tarqalgan bo'lsa-da:

            
async function* generateValues() {
  yield Promise.resolve(1);
  yield Promise.resolve(2);
  yield Promise.resolve(3);
}

(async () => {
  const iterator = generateValues();

  let result = await iterator.next();
  console.log(result); // Chiqish: { value: 1, done: false }

  result = await iterator.next();
  console.log(result); // Chiqish: { value: 2, done: false }

  result = await iterator.next();
  console.log(result); // Chiqish: { value: 3, done: false }

  result = await iterator.next();
  console.log(result); // Chiqish: { value: undefined, done: true }
})();

            

              
                Copy
              
            
          

Asinxron Generatorlar bilan Oqimli Ma'lumotlarni Qayta Ishlash

Asinxron generatorlar ayniqsa oqimli ma'lumotlarni qayta ishlash uchun juda mos keladi. Oqimli qayta ishlash ma'lumotlarni bir vaqtning o'zida butun to'plamni qayta ishlash o'rniga, uzluksiz oqim sifatida ishlashni o'z ichiga oladi. Bu yondashuv ayniqsa katta ma'lumotlar to'plamlari, real vaqtdagi ma'lumotlar oqimlari yoki I/O bilan bog'liq operatsiyalar bilan ishlashda foydalidir.

Tasavvur qiling, siz bir nechta serverlardan log fayllarini qayta ishlaydigan tizim yaratmoqdasiz. Butun log fayllarini xotiraga yuklash o'rniga, siz asinxron generator yordamida log fayllarini qatorma-qator o'qib, har bir qatorni asinxron ravishda qayta ishlashingiz mumkin. Bu xotira muammolarining oldini oladi va log ma'lumotlari paydo bo'lishi bilan ularni qayta ishlashni boshlashga imkon beradi.

Bu yerda Node.js da asinxron generator yordamida faylni qatorma-qator o'qish misoli keltirilgan:

            
const fs = require('fs');
const readline = require('readline');

async function* readLines(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

(async () => {
  const filePath = 'path/to/your/log/file.txt'; // Haqiqiy fayl yo'li bilan almashtiring
  for await (const line of readLines(filePath)) {
    // Har bir qatorni shu yerda qayta ishlang
    console.log(`Qator: ${line}`);
  }
})();

            

              
                Copy
              
            
          

Ushbu misolda readLines — Node.js ning fs va readline modullaridan foydalanib faylni qatorma-qator o'qiydigan asinxron generator. Keyin for await...of tsikli qatorlar bo'ylab iteratsiya qilib, har bir qatorni paydo bo'lishi bilan qayta ishlaydi. crlfDelay: Infinity opsiyasi turli operatsion tizimlarda (Windows, macOS, Linux) qator oxirini to'g'ri ishlashini ta'minlaydi.

Orqaga Bosim: Asinxron Ma'lumotlar Oqimini Boshqarish

Ma'lumotlar oqimlarini qayta ishlashda orqaga bosimni boshqarish juda muhim. Orqaga bosim ma'lumotlar ishlab chiqarish tezligi (yuqori oqim tomonidan) ularni iste'mol qilish tezligidan (quyi oqim tomonidan) oshib ketganda yuzaga keladi. Agar to'g'ri boshqarilmasa, orqaga bosim ishlash samaradorligi muammolariga, xotiraning to'lib ketishiga yoki hatto ilovaning ishdan chiqishiga olib kelishi mumkin.

Asinxron generatorlar orqaga bosimni boshqarish uchun tabiiy mexanizmni taqdim etadi. yield kalit so'zi keyingi qiymat talab qilinmaguncha generatorni yashirincha to'xtatib turadi, bu esa iste'molchiga ma'lumotlarni qayta ishlash tezligini nazorat qilish imkonini beradi. Bu ayniqsa iste'molchi har bir ma'lumot elementi ustida qimmat operatsiyalarni bajaradigan stsenariylarda muhimdir.

Tashqi API'dan ma'lumotlarni olib, ularni qayta ishlayotgan misolni ko'rib chiqaylik. API ma'lumotlarni sizning ilovangiz qayta ishlashi mumkin bo'lganidan ancha tezroq yuborishi mumkin. Orqaga bosimsiz ilovangiz haddan tashqari yuklanishi mumkin.

            
async function* fetchDataFromAPI(url) {
  let page = 1;
  while (true) {
    const response = await fetch(`${url}?page=${page}`);
    const data = await response.json();

    if (data.length === 0) {
      break; // Boshqa ma'lumot yo'q
    }

    for (const item of data) {
      yield item;
    }

    page++;
    // Bu yerda aniq kechikish yo'q, tezlikni nazorat qilish iste'molchiga bog'liq
  }
}

async function processData() {
  const apiURL = 'https://api.example.com/data'; // O'zingizning API URL manzilingiz bilan almashtiring
  for await (const item of fetchDataFromAPI(apiURL)) {
    // Qimmat qayta ishlashni simulyatsiya qilish
    await new Promise(resolve => setTimeout(resolve, 100)); // 100ms kechikish
    console.log('Qayta ishlanmoqda:', item);
  }
}

processData();

            

              
                Copy
              
            
          

Ushbu misolda fetchDataFromAPI — API'dan sahifalar bo'yicha ma'lumotlarni oladigan asinxron generator. processData funksiyasi ma'lumotlarni iste'mol qiladi va har bir element uchun 100 ms kechikish qo'shib, qimmat qayta ishlashni simulyatsiya qiladi. Iste'molchidagi kechikish samarali ravishda orqaga bosim yaratadi va generatorning ma'lumotlarni juda tez olishiga yo'l qo'ymaydi.

Aniq Orqaga Bosim Mexanizmlari: yieldning tabiiy to'xtab turishi asosiy orqaga bosimni ta'minlasa-da, siz aniqroq mexanizmlarni ham joriy qilishingiz mumkin. Masalan, ma'lumotlar oqimini yanada nazorat qilish uchun bufer yoki tezlik cheklovchisini kiritishingiz mumkin.

Ilg'or Texnikalar va Amaliy Holatlar

Oqimlarni O'zgartirish

Murakkab ma'lumotlarni qayta ishlash quvurlarini yaratish uchun asinxron generatorlarni bir-biriga bog'lash mumkin. Boshqa bir asinxron generator tomonidan qaytarilgan ma'lumotlarni o'zgartirish uchun bitta asinxron generatordan foydalanishingiz mumkin. Bu sizga modulli va qayta ishlatiladigan ma'lumotlarni qayta ishlash komponentlarini yaratish imkonini beradi.

            
async function* transformData(source) {
  for await (const item of source) {
    const transformedItem = item * 2; // O'zgartirish misoli
    yield transformedItem;
  }
}

// Foydalanish (oldingi misoldagi fetchDataFromAPI deb faraz qilinadi)
(async () => {
  const apiURL = 'https://api.example.com/data'; // O'zingizning API URL manzilingiz bilan almashtiring
  const transformedStream = transformData(fetchDataFromAPI(apiURL));

  for await (const item of transformedStream) {
    console.log('O`zgartirildi:', item);
  }
})();

            

              
                Copy
              
            
          

Xatoliklarni Boshqarish

Asinxron operatsiyalar bilan ishlashda xatoliklarni boshqarish juda muhim. Ma'lumotlarni qayta ishlash jarayonida yuzaga keladigan xatoliklarni boshqarish uchun asinxron generatorlar ichida try...catch bloklaridan foydalanishingiz mumkin. Shuningdek, iste'molchiga xatolik haqida signal berish uchun asinxron iteratorning throw metodidan foydalanishingiz mumkin.

            
async function* processDataWithErrorHandling(source) {
  try {
    for await (const item of source) {
      if (item === null) {
        throw new Error('Yaroqsiz ma`lumot: null qiymat topildi');
      }
      yield item;
    }
  } catch (error) {
    console.error('Generatordagi xatolik:', error);
    // Ixtiyoriy ravishda xatolikni iste'molchiga uzatish uchun qayta 'throw' qilish
    // throw error;
  }
}

(async () => {
    async function* generateWithNull(){
        yield 1;
        yield null;
        yield 3;
    }

  const dataStream = processDataWithErrorHandling(generateWithNull());

  try {
    for await (const item of dataStream) {
      console.log('Qayta ishlanmoqda:', item);
    }
  } catch (error) {
    console.error('Iste`molchidagi xatolik:', error);
  }
})();

            

              
                Copy
              
            
          

Haqiqiy Dunyodagi Amaliy Holatlar

• Real vaqtdagi ma'lumotlar quvurlari: Sensorlar, moliyaviy bozorlar yoki ijtimoiy media oqimlaridan ma'lumotlarni qayta ishlash. Asinxron generatorlar ushbu uzluksiz ma'lumotlar oqimlarini samarali boshqarish va hodisalarga real vaqtda javob berish imkonini beradi. Masalan, aksiya narxlarini kuzatish va ma'lum bir chegaraga yetganda ogohlantirishlarni ishga tushirish.
• Katta fayllarni qayta ishlash: Katta log fayllarini, CSV fayllarini yoki multimedia fayllarini o'qish va qayta ishlash. Asinxron generatorlar butun faylni xotiraga yuklashdan saqlaydi, bu esa mavjud RAM hajmidan kattaroq fayllarni qayta ishlashga imkon beradi. Masalan, veb-sayt trafigi loglarini tahlil qilish yoki video oqimlarini qayta ishlash.
• Ma'lumotlar bazasi bilan o'zaro aloqa: Ma'lumotlar bazalaridan katta ma'lumotlar to'plamlarini bo'laklarga bo'lib olish. Asinxron generatorlar butun to'plamni xotiraga yuklamasdan natijalar to'plami bo'ylab iteratsiya qilish uchun ishlatilishi mumkin. Bu ayniqsa katta jadvallar yoki murakkab so'rovlar bilan ishlashda foydalidir. Masalan, katta ma'lumotlar bazasidagi foydalanuvchilar ro'yxatini sahifalarga bo'lish.
• Mikroservislar aloqasi: Mikroservislar o'rtasidagi asinxron xabarlarni boshqarish. Asinxron generatorlar xabar navbatlaridan (masalan, Kafka, RabbitMQ) hodisalarni qayta ishlashni va ularni quyi oqim xizmatlari uchun o'zgartirishni osonlashtirishi mumkin.
• WebSockets va Server-Sent Events (SSE): Serverlardan mijozlarga yuboriladigan real vaqtdagi ma'lumotlarni qayta ishlash. Asinxron generatorlar WebSockets yoki SSE oqimlaridan keladigan xabarlarni samarali boshqarishi va foydalanuvchi interfeysini shunga mos ravishda yangilashi mumkin. Masalan, sport o'yini yoki moliyaviy paneldan jonli yangilanishlarni ko'rsatish.

Asinxron Generatorlardan Foydalanishning Afzalliklari

• Yaxshilangan ishlash samaradorligi: Asinxron generatorlar bloklanmaydigan I/O operatsiyalarini amalga oshirishga imkon beradi, bu esa ilovalaringizning javob berish qobiliyati va kengayuvchanligini yaxshilaydi.
• Kamaytirilgan xotira iste'moli: Asinxron generatorlar bilan oqimli qayta ishlash katta ma'lumotlar to'plamlarini xotiraga yuklashdan saqlaydi, bu esa xotira hajmini kamaytiradi va xotira yetishmovchiligi xatolarining oldini oladi.
• Soddalashtirilgan kod: Asinxron generatorlar an'anaviy callback yoki promise asosidagi yondashuvlarga qaraganda asinxron ma'lumotlar oqimlari bilan ishlashning toza va o'qilishi osonroq usulini taqdim etadi.
• Kengaytirilgan xatoliklarni boshqarish: Asinxron generatorlar xatoliklarni chiroyli tarzda boshqarish va ularni iste'molchiga uzatish imkonini beradi.
• Orqaga bosimni boshqarish: Asinxron generatorlar orqaga bosimni boshqarish uchun o'rnatilgan mexanizmni taqdim etadi, bu ma'lumotlarning haddan tashqari yuklanishini oldini oladi va silliq ma'lumotlar oqimini ta'minlaydi.
• Kompozitsionlik: Asinxron generatorlarni murakkab ma'lumotlarni qayta ishlash quvurlarini yaratish uchun bir-biriga bog'lash mumkin, bu modullik va qayta foydalanish imkoniyatini oshiradi.

Asinxron Generatorlarga Alternativalar

Asinxron generatorlar oqimli qayta ishlash uchun kuchli yondashuvni taklif qilsa-da, har birining o'z afzalliklari va kamchiliklari bo'lgan boshqa variantlar ham mavjud.

• Observables (RxJS): Observables, ayniqsa RxJS kabi kutubxonalardan, asinxron ma'lumotlar oqimlari uchun mustahkam va ko'p funksiyali freymvorkni taqdim etadi. Ular oqimlarni o'zgartirish, filtrlash va birlashtirish uchun operatorlarni hamda orqaga bosimni a'lo darajada nazorat qilishni taklif qiladi. Biroq, RxJS ni o'rganish asinxron generatorlarga qaraganda qiyinroq va loyihangizga ko'proq murakkablik kiritishi mumkin.
• Streams API (Node.js): Node.js ning o'rnatilgan Streams API si oqimli ma'lumotlarni boshqarish uchun quyi darajadagi mexanizmni taqdim etadi. U turli xil oqim turlarini (o'qiladigan, yoziladigan, o'zgartiruvchi) va hodisalar hamda metodlar orqali orqaga bosimni nazorat qilishni taklif qiladi. Streams API asinxron generatorlarga qaraganda ko'proq so'zli bo'lishi va ko'proq qo'lda boshqaruvni talab qilishi mumkin.
• Callback yoki Promise asosidagi yondashuvlar: Ushbu yondashuvlar asinxron dasturlash uchun ishlatilishi mumkin bo'lsa-da, ular ko'pincha murakkab va qo'llab-quvvatlash qiyin bo'lgan kodga olib keladi, ayniqsa oqimlar bilan ishlashda. Ular, shuningdek, orqaga bosim mexanizmlarini qo'lda amalga oshirishni talab qiladi.

Xulosa

JavaScript asinxron generatorlari asinxron JavaScript ilovalarida oqimli ma'lumotlarni qayta ishlash va orqaga bosimni boshqarish uchun kuchli va elegant yechimni taklif etadi. Asinxron funksiyalar va generatorlarning afzalliklarini birlashtirib, ular katta ma'lumotlar to'plamlari, real vaqtdagi ma'lumotlar oqimlari va I/O bilan bog'liq operatsiyalarni boshqarishning moslashuvchan va samarali usulini taqdim etadi. Asinxron generatorlarni tushunish zamonaviy, kengaytiriladigan va sezgir veb-ilovalarni yaratish uchun juda muhimdir. Ular ma'lumotlar oqimlarini boshqarishda va ilovangiz ma'lumotlar oqimini samarali boshqarishini ta'minlashda, ishlashdagi to'siqlarning oldini olishda va silliq foydalanuvchi tajribasini ta'minlashda, ayniqsa tashqi APIlar, katta fayllar yoki real vaqtdagi ma'lumotlar bilan ishlashda ustunlikka ega.

Asinxron generatorlarni tushunish va ulardan foydalanish orqali dasturchilar zamonaviy ma'lumotlarga boy muhit talablariga javob bera oladigan yanada mustahkam, kengaytiriladigan va qo'llab-quvvatlanadigan ilovalarni yaratishlari mumkin. Real vaqtdagi ma'lumotlar quvurini qurasizmi, katta fayllarni qayta ishlayapsizmi yoki ma'lumotlar bazalari bilan ishlayapsizmi, asinxron generatorlar asinxron ma'lumotlar muammolarini hal qilish uchun qimmatli vositani taqdim etadi.